/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import CryptoJS from './crypto-js.js'

let key = 'kJeZr6b2u3*mABFB'
let content = 'ABCDEFGHIJKabcdefj123456+/AA==!@一段中文';
let contentArray = []
let content1k = ""
let hexContent1k = ''
for (let i = 0; i < content.length; i++) {
    contentArray.push(content[i]);
}
let dic = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
let dic1 = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', "a", "b", "b", "d", "e", "f"]
for (let i = 0; i < 1024; i++) {
    content1k += dic[i / 10]
}
for (let i = 0; i < 1024; i++) {
    hexContent1k += dic1[i % 15]
}

function crypto_Test_01() {
    const expectStr = '155d44e00cbbfbfd8664f5f79626ed1f'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.MD5(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'MD5 error'
    }
    print(`crypto-js_MD5(string): ${endTime - startTime} ms`)
}

function crypto_Test_02() {
    const expectStr = '487f7b22f68312d2c1bbc93b1aea445b'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.MD5(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'MD5 error'
    }
    print(`crypto-js_MD5(array): ${endTime - startTime} ms`)
}

function crypto_Test_03() {
    const expectStr = '788f1b73798c0c1008497ac1a63a34456b8ac00c'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA1(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA1 error'
    }
    print(`crypto-js_SHA1(string): ${endTime - startTime} ms`)
}

function crypto_Test_04() {
    const expectStr = '9844f81e1408f6ecb932137d33bed7cfdcf518a3'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA1(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA1 error'
    }
    print(`crypto-js_SHA1(array): ${endTime - startTime} ms`)
}

function crypto_Test_05() {
    const expectStr = 'f460983224e7b4cc89abcca295bbd725293abaac2b5c7d2d5cd26490'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA224(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA224 error'
    }
    print(`crypto-js_SHA224(string): ${endTime - startTime} ms`)
}

function crypto_Test_06() {
    const expectStr = '9d6a5de9e16c3999c714840f47771f36dcc297a7bdefaac36c9515ae'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA224(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA224 error'
    }
    print(`crypto-js_SHA224(array): ${endTime - startTime} ms`)
}

function crypto_Test_07() {
    const expectStr = 'c761e44973023d03277f6a30fb6278f5be064876793a66270150cda98538a5ec'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA256(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA256 error'
    }
    print(`crypto-js_SHA256(string): ${endTime - startTime} ms`)
}

function crypto_Test_08() {
    const expectStr = '4ea5c508a6566e76240543f8feb06fd457777be39549c4016436afda65d2330e'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA256(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA256 error'
    }
    print(`crypto-js_SHA256(array): ${endTime - startTime} ms`)
}

function crypto_Test_09() {
    const expectStr = '80b98ab583374e9480d33c39efea1b4b4a1773e61d7bea85be6cd7c1fa1330f4d2561312acda27f96c60a3e45a274973'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA384(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA384 error'
    }
    print(`crypto-js_SHA384(string): ${endTime - startTime} ms`)
}

function crypto_Test_10() {
    const expectStr = '1402e01a160a97a99698ba6657b0feeef3d663056e532cbc19fe8e1b37076dd12193a48528b07adaadfe0d0991847f10'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA384(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA384 error'
    }
    print(`crypto-js_SHA384(array): ${endTime - startTime} ms`)
}

function crypto_Test_11() {
    const expectStr = '2921ea701c7e1f633ffa4d1660700b90ba726ddc9a432b00b1a923baf8bab1f3f27e68a269724e427bb7a34ba419ed9014265d42f9d1fca9a78f1148f2fdd7f5'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA512(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA512 error'
    }
    print(`crypto-js_SHA512(string): ${endTime - startTime} ms`)
}

function crypto_Test_12() {
    const expectStr = '632008c3b59e037f2e761675c88296e146add6240cb9d35ec6366041238417ea833675ce168e34a852457224a827a0ff2e723a95ae682458c6ef4baee2118c71'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA512(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA512 error'
    }
    print(`crypto-js_SHA512(array): ${endTime - startTime} ms`)
}

function crypto_Test_13() {
    const expectStr = '1283724d207f525ea488e48a679dc373703aad10d2d8d27d8a0426450bf5d0e2f4e89421777a031195d5f73cee2b861e6427d34eb3548c75e083d339934e0846'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA3(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA3 error'
    }
    print(`crypto-js_SHA3(string): ${endTime - startTime} ms`)
}

function crypto_Test_14() {
    const expectStr = 'b4047203bcc7e1b9c0b3f2dd9656a3f82a01630cb88a57d79c7d9c1c6b4c80d2'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.SHA3(content, { outputLength: 256 })
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'SHA3 error'
    }
    print(`crypto-js_SHA3(outputLength): ${endTime - startTime} ms`)
}

function crypto_Test_15() {
    const expectStr = '1b61a77f30ab312305d0f0f1e70689ed311e2cd3'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RIPEMD160(content)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'RIPEMD160 error'
    }
    print(`crypto-js_RIPEMD160(string): ${endTime - startTime} ms`)
}

function crypto_Test_16() {
    const expectStr = '550f7c7c5e9edb0d697815bf657e14ea0ebb89cb'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RIPEMD160(contentArray)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'RIPEMD160 error'
    }
    print(`crypto-js_RIPEMD160(array): ${endTime - startTime} ms`)
}

function crypto_Test_17() {
    const expectStr = 'a600895af5e036adc0c275be37941fbd'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacMD5(content, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacMD5 error'
    }
    print(`crypto-js_HmacMD5(string): ${endTime - startTime} ms`)
}

function crypto_Test_18() {
    const expectStr = '26c7833a94f01ec05dde91523daca0c3'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacMD5(contentArray, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacMD5 error'
    }
    print(`crypto-js_HmacMD5(array): ${endTime - startTime} ms`)
}

function crypto_Test_19() {
    const expectStr = 'b7871b314a3ab47477f03a68126d4151868c51f8'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacSHA1(content, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacSHA1 error'
    }
    print(`crypto-js_HmacSHA1(string): ${endTime - startTime} ms`)
}

function crypto_Test_20() {
    const expectStr = '96638de9a83c2c21ff750c77af008c347044d019'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacSHA1(contentArray, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacSHA1 error'
    }
    print(`crypto-js_HmacSHA1(array): ${endTime - startTime} ms`)
}

function crypto_Test_21() {
    const expectStr = '3e111cb6725e9913f276dfcd003d36e61344888f6d4438175a6a2d3d32c2f18f'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacSHA256(content, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacSHA256 error'
    }
    print(`crypto-js_HmacSHA256(string): ${endTime - startTime} ms`)
}

function crypto_Test_22() {
    const expectStr = '582b5848518285249e82ae8746aa5213b95653059a68f9ae01fe4da8886caf4e'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacSHA256(contentArray, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacSHA256 error'
    }
    print(`crypto-js_HmacSHA256(array): ${endTime - startTime} ms`)
}

function crypto_Test_23() {
    const expectStr = '51fdd21ddf2444fc2d9c15c84a99fb580eb32adb048ddcb1a870cf6cce5add04b3fdd4bc397c4131ddfd0ca95e4eadd80bbb5993b070558e5c7d56665c18df11'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacSHA512(content, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacSHA512 error'
    }
    print(`crypto-js_HmacSHA512(string): ${endTime - startTime} ms`)
}

function crypto_Test_24() {
    const expectStr = '9e268708ff9ea30e768698b2b5a4ea14de72978d2170f989c42b777c8095d531bd582636bc1256bed2856654d019eb41f678abc8a7b6155560a34f0c79bc2fbc'
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.HmacSHA512(contentArray, key)
    }
    let endTime = Date.now()
    if (result.toString() != expectStr) {
        throw 'HmacSHA512 error'
    }
    print(`crypto-js_HmacSHA512(array): ${endTime - startTime} ms`)
}

function crypto_Test_25() {
    var salt = CryptoJS.lib.WordArray.random(128 / 8);
    let result = null
    let startTime = Date.now()
    // for (let i = 0; i < 1; i++) {
    result = CryptoJS.PBKDF2(key, salt, {
        keySize: 128 / 32
    });
    // }
    let endTime = Date.now()
    if (result == null) {
        throw 'PBKDF2 error'
    }
    print(`crypto-js_PBKDF2: ${endTime - startTime} ms`)
}

function crypto_Test_26() {
    var salt = CryptoJS.lib.WordArray.random(128 / 8);
    let result = null
    let startTime = Date.now()
    // for (let i = 0; i < 1; i++) {
    result = CryptoJS.PBKDF2(key, salt, {
        keySize: 512 / 32,
        iterations: 1000
    });
    // }
    let endTime = Date.now()
    if (result == null) {
        throw 'PBKDF2 error'
    }
    print(`crypto-js_PBKDF2(iterations): ${endTime - startTime} ms`)
}

function crypto_Test_27() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.encrypt(content, key)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.AES.decrypt(result, key)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.encrypt error'
    }
    print(`crypto-js_AES.encrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_28() {
    const encrypted = CryptoJS.AES.encrypt(content, key)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.decrypt(encrypted, key)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.decrypt error'
    }
    print(`crypto-js_AES.decrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_29() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.encrypt(content, key)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.DES.decrypt(result, key)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.encrypt error'
    }
    print(`crypto-js_DES.encrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_30() {
    const encrypted = CryptoJS.DES.encrypt(content, key)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.decrypt(encrypted, key)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.decrypt error'
    }
    print(`crypto-js_DES.decrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_31() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.TripleDES.encrypt(content, key)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.TripleDES.decrypt(result, key)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'TripleDES.encrypt error'
    }
    print(`crypto-js_TripleDES.encrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_32() {
    const encrypted = CryptoJS.TripleDES.encrypt(content, key)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.TripleDES.decrypt(encrypted, key)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'TripleDES.decrypt error'
    }
    print(`crypto-js_TripleDES.decrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_33() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.encrypt(content, key)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.Rabbit.decrypt(result, key)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.encrypt error'
    }
    print(`crypto-js_Rabbit.encrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_34() {
    const encrypted = CryptoJS.Rabbit.encrypt(content, key)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.decrypt(encrypted, key)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.decrypt error'
    }
    print(`crypto-js_Rabbit.decrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_35() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.encrypt(content, key)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.RC4.decrypt(result, key)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.encrypt error'
    }
    print(`crypto-js_RC4.encrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_36() {
    const encrypted = CryptoJS.RC4.encrypt(content, key)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.decrypt(encrypted, key)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.decrypt error'
    }
    print(`crypto-js_RC4.decrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_37() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4Drop.encrypt(content, key)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.RC4Drop.decrypt(result, key)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4Drop.encrypt error'
    }
    print(`crypto-js_RC4Drop.encrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_38() {
    const encrypted = CryptoJS.RC4Drop.encrypt(content, key)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4Drop.decrypt(encrypted, key)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4Drop.decrypt error'
    }
    print(`crypto-js_RC4Drop.decrypt(string): ${endTime - startTime} ms`)
}

function crypto_Test_39() {
    var key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.encrypt(content, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.AES.decrypt(result, key1, { iv: iv1 })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.encrypt error'
    }
    print(`crypto-js_AES.encrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_40() {
    var key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    const encrypted = CryptoJS.AES.encrypt(content, key1, { iv: iv1 })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.decrypt(encrypted, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.decrypt error'
    }
    print(`crypto-js_AES.decrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_41() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.encrypt(content, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.AES.decrypt(result, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.encrypt error'
    }
    print(`crypto-js_AES.encrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_42() {
    const encrypted = CryptoJS.AES.encrypt(content, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.decrypt(encrypted, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.decrypt error'
    }
    print(`crypto-js_AES.decrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_43() {
    var key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.encrypt(content, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.DES.decrypt(result, key1, { iv: iv1 })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.encrypt error'
    }
    print(`crypto-js_DES.encrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_44() {
    var key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    const encrypted = CryptoJS.DES.encrypt(content, key1, { iv: iv1 })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.decrypt(encrypted, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.decrypt error'
    }
    print(`crypto-js_DES.decrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_45() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.encrypt(content, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.DES.decrypt(result, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.encrypt error'
    }
    print(`crypto-js_DES.encrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_46() {
    const encrypted = CryptoJS.DES.encrypt(content, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.decrypt(encrypted, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.decrypt error'
    }
    print(`crypto-js_DES.decrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_47() {
    var key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.encrypt(content, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.RC4.decrypt(result, key1, { iv: iv1 })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.encrypt error'
    }
    print(`crypto-js_RC4.encrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_48() {
    var key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    const encrypted = CryptoJS.RC4.encrypt(content, key1, { iv: iv1 })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.decrypt(encrypted, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.decrypt error'
    }
    print(`crypto-js_RC4.decrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_49() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.encrypt(content, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.RC4.decrypt(result, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.encrypt error'
    }
    print(`crypto-js_RC4.encrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_50() {
    const encrypted = CryptoJS.RC4.encrypt(content, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.decrypt(encrypted, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.decrypt error'
    }
    print(`crypto-js_RC4.decrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_51() {
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.encrypt(content, CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f"), { iv: iv1 })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.Rabbit.decrypt(result, CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f"), { iv: iv1 })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.encrypt error'
    }
    print(`crypto-js_Rabbit.encrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_52() {
    var key1 = key;
    var iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    const encrypted = CryptoJS.Rabbit.encrypt(content, key1, { iv: iv1 })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.decrypt(encrypted, key1, { iv: iv1 })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.decrypt error'
    }
    print(`crypto-js_Rabbit.decrypt(key, iv): ${endTime - startTime} ms`)
}

function crypto_Test_53() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.encrypt(content, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.Rabbit.decrypt(result, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.encrypt error'
    }
    print(`crypto-js_Rabbit.encrypt(mode, padding): ${endTime - startTime} ms`)
}

function crypto_Test_54() {
    const encrypted = CryptoJS.Rabbit.encrypt(content, key, {
        mode: CryptoJS.mode.CFB,
        padding: CryptoJS.pad.AnsiX923
    })
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.decrypt(encrypted, key, {
            mode: CryptoJS.mode.CFB,
            padding: CryptoJS.pad.AnsiX923
        })
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.decrypt error'
    }
    print(`crypto-js_Rabbit.decrypt(mode, padding): ${endTime - startTime} ms`)
}

var JsonFormatter = {
    stringify: function (cipherParams) {
        // create json object with ciphertext
        var jsonObj = { ct: cipherParams.ciphertext.toString(CryptoJS.enc.Base64) };

        // optionally add iv or salt
        if (cipherParams.iv) {
            jsonObj.iv = cipherParams.iv.toString();
        }

        if (cipherParams.salt) {
            jsonObj.s = cipherParams.salt.toString();
        }

        // stringify json object
        return JSON.stringify(jsonObj);
    },
    parse: function (jsonStr) {
        // parse json string
        var jsonObj = JSON.parse(jsonStr);

        // extract ciphertext from json object, and create cipher params object
        var cipherParams = CryptoJS.lib.CipherParams.create({
            ciphertext: CryptoJS.enc.Base64.parse(jsonObj.ct)
        });

        // optionally extract iv or salt

        if (jsonObj.iv) {
            cipherParams.iv = CryptoJS.enc.Hex.parse(jsonObj.iv);
        }

        if (jsonObj.s) {
            cipherParams.salt = CryptoJS.enc.Hex.parse(jsonObj.s);
        }

        return cipherParams;
    }
};

function crypto_Test_55() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.encrypt(content, key, JsonFormatter)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.AES.decrypt(result, key, JsonFormatter)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.encrypt error'
    }
    print(`crypto-js_AES.encrypt(format): ${endTime - startTime} ms`)

}

function crypto_Test_56() {
    const encrypted = CryptoJS.AES.encrypt(content, key, JsonFormatter)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.AES.decrypt(encrypted, key, JsonFormatter)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'AES.decrypt error'
    }
    print(`crypto-js_AES.decrypt(format): ${endTime - startTime} ms`)
}

function crypto_Test_57() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.encrypt(content, key, JsonFormatter)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.DES.decrypt(result, key, JsonFormatter)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.encrypt error'
    }
    print(`crypto-js_DES.encrypt(format): ${endTime - startTime} ms`)

}

function crypto_Test_58() {
    const encrypted = CryptoJS.DES.encrypt(content, key, JsonFormatter)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.DES.decrypt(encrypted, key, JsonFormatter)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'DES.decrypt error'
    }
    print(`crypto-js_DES.decrypt(format): ${endTime - startTime} ms`)
}

function crypto_Test_59() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.encrypt(content, key, JsonFormatter)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.RC4.decrypt(result, key, JsonFormatter)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.encrypt error'
    }
    print(`crypto-js_RC4.encrypt(format): ${endTime - startTime} ms`)

}

function crypto_Test_60() {
    const encrypted = CryptoJS.RC4.encrypt(content, key, JsonFormatter)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.RC4.decrypt(encrypted, key, JsonFormatter)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'RC4.decrypt error'
    }
    print(`crypto-js_RC4.decrypt(format): ${endTime - startTime} ms`)
}

function crypto_Test_61() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.encrypt(content, key, JsonFormatter)
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.Rabbit.decrypt(result, key, JsonFormatter)
    if (expectStr.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.encrypt error'
    }
    print(`crypto-js_Rabbit.encrypt(format): ${endTime - startTime} ms`)

}

function crypto_Test_62() {
    const encrypted = CryptoJS.Rabbit.encrypt(content, key, JsonFormatter)
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.Rabbit.decrypt(encrypted, key, JsonFormatter)
    }
    let endTime = Date.now()
    if (result.toString(CryptoJS.enc.Utf8) != content) {
        throw 'Rabbit.decrypt error'
    }
    print(`crypto-js_Rabbit.decrypt(format): ${endTime - startTime} ms`)
}

function crypto_Test_63() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesEncryptor = CryptoJS.algo.AES.createEncryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    var aesDecryptor = CryptoJS.algo.AES.createDecryptor(key1, { iv: iv1 });
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'AES.createEncryptor error'
    }
    print(`crypto-js_AES.createEncryptor: ${endTime - startTime} ms`)
}

function crypto_Test_64() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = CryptoJS.algo.AES.createEncryptor(key1, { iv: iv1 });
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    let aesDecryptor = null;
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesDecryptor = CryptoJS.algo.AES.createDecryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'AES.createDecryptor error'
    }
    print(`crypto-js_AES.createDecryptor: ${endTime - startTime} ms`)
}

function crypto_Test_65() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesEncryptor = CryptoJS.algo.DES.createEncryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    var aesDecryptor = CryptoJS.algo.DES.createDecryptor(key1, { iv: iv1 });
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'DES.createEncryptor error'
    }
    print(`crypto-js_DES.createEncryptor: ${endTime - startTime} ms`)
}

function crypto_Test_66() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = CryptoJS.algo.DES.createEncryptor(key1, { iv: iv1 });
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    let aesDecryptor = null;
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesDecryptor = CryptoJS.algo.DES.createDecryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'DES.createDecryptor error'
    }
    print(`crypto-js_DES.createDecryptor: ${endTime - startTime} ms`)
}

function crypto_Test_67() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesEncryptor = CryptoJS.algo.RC4.createEncryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    var aesDecryptor = CryptoJS.algo.RC4.createDecryptor(key1, { iv: iv1 });
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'RC4.createEncryptor error'
    }
    print(`crypto-js_RC4.createEncryptor: ${endTime - startTime} ms`)
}

function crypto_Test_68() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = CryptoJS.algo.RC4.createEncryptor(key1, { iv: iv1 });
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    let aesDecryptor = null;
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesDecryptor = CryptoJS.algo.RC4.createDecryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'RC4.createDecryptor error'
    }
    print(`crypto-js_RC4.createDecryptor: ${endTime - startTime} ms`)
}

function crypto_Test_69() {
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesEncryptor = CryptoJS.algo.Rabbit.createEncryptor(CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f"), { iv: iv1 });
    }
    let endTime = Date.now()
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    var aesDecryptor = CryptoJS.algo.Rabbit.createDecryptor(CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f"), { iv: iv1 });
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'Rabbit.createEncryptor error'
    }
    print(`crypto-js_Rabbit.createEncryptor: ${endTime - startTime} ms`)
}

function crypto_Test_70() {
    const key1 = CryptoJS.enc.Hex.parse("000102030405060708090a0b0c0d0e0f");
    const iv1 = CryptoJS.enc.Hex.parse("101112131415161718191a1b1c1d1e1f");
    let aesEncryptor = CryptoJS.algo.Rabbit.createEncryptor(key1, { iv: iv1 });
    let ciphertextPart1 = aesEncryptor.process(content);
    let ciphertextPart2 = aesEncryptor.finalize();
    let aesDecryptor = null;
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        aesDecryptor = CryptoJS.algo.Rabbit.createDecryptor(key1, { iv: iv1 });
    }
    let endTime = Date.now()
    var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
    var plaintextPart2 = aesDecryptor.finalize(ciphertextPart2);
    var result = plaintextPart1.toString(CryptoJS.enc.Utf8) + plaintextPart2.toString(CryptoJS.enc.Utf8)
    if (result != content) {
        throw 'Rabbit.createDecryptor error'
    }
    print(`crypto-js_Rabbit.createDecryptor: ${endTime - startTime} ms`)
}

function crypto_Test_71() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Base64.parse(content1k);
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.enc.Base64.stringify(result)
    if (expectStr != content1k) {
        throw 'Base64.parse error'
    }
    print(`crypto-js_Base64.parse: ${endTime - startTime} ms`)
}

function crypto_Test_72() {
    let result = null
    let words = CryptoJS.enc.Base64.parse(content1k);
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Base64.stringify(words);
    }
    let endTime = Date.now()
    if (result != content1k) {
        throw 'Base64.stringify error'
    }
    print(`crypto-js_Base64.stringify: ${endTime - startTime} ms`)
}

function crypto_Test_73() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Latin1.parse(content1k);
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.enc.Latin1.stringify(result)
    if (expectStr != content1k) {
        throw 'Latin1.parse error'
    }
    print(`crypto-js_Latin1.parse: ${endTime - startTime} ms`)
}

function crypto_Test_74() {
    let result = null
    let words = CryptoJS.enc.Latin1.parse(content1k);
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Latin1.stringify(words);
    }
    let endTime = Date.now()
    if (result != content1k) {
        throw 'Latin1.stringify error'
    }
    print(`crypto-js_Latin1.stringify: ${endTime - startTime} ms`)
}

function crypto_Test_75() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Hex.parse(hexContent1k);
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.enc.Hex.stringify(result)
    if (expectStr != hexContent1k) {
        throw 'Hex.parse error'
    }
    print(`crypto-js_Hex.parse: ${endTime - startTime} ms`)
}

function crypto_Test_76() {
    let result = null
    let words = CryptoJS.enc.Hex.parse(hexContent1k);
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Hex.stringify(words);
    }
    let endTime = Date.now()
    if (result != hexContent1k) {
        throw 'Hex.stringify error'
    }
    print(`crypto-js_Hex.stringify: ${endTime - startTime} ms`)
}

function crypto_Test_77() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Utf8.parse(content1k);
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.enc.Utf8.stringify(result)
    if (expectStr != content1k) {
        throw 'Utf8.parse error'
    }
    print(`crypto-js_Utf8.parse: ${endTime - startTime} ms`)
}

function crypto_Test_78() {
    let result = null
    let words = CryptoJS.enc.Utf8.parse(content1k);
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Utf8.stringify(words);
    }
    let endTime = Date.now()
    if (result != content1k) {
        throw 'Utf8.stringify error'
    }
    print(`crypto-js_Utf8.stringify: ${endTime - startTime} ms`)
}

function crypto_Test_79() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Utf16.parse(content1k);
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.enc.Utf16.stringify(result)
    if (expectStr != content1k) {
        throw 'Utf16.parse error'
    }
    print(`crypto-js_Utf16.parse: ${endTime - startTime} ms`)
}

function crypto_Test_80() {
    let result = null
    let words = CryptoJS.enc.Utf16.parse(content1k);
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Utf16.stringify(words);
    }
    let endTime = Date.now()
    if (result != content1k) {
        throw 'Utf16.stringify error'
    }
    print(`crypto-js_Utf16.stringify: ${endTime - startTime} ms`)
}

function crypto_Test_81() {
    let result = null
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Utf16LE.parse(content1k);
    }
    let endTime = Date.now()
    const expectStr = CryptoJS.enc.Utf16LE.stringify(result)
    if (expectStr != content1k) {
        throw 'Utf16LE.parse error'
    }
    print(`crypto-js_Utf16LE.parse: ${endTime - startTime} ms`)
}

function crypto_Test_82() {
    let result = null
    let words = CryptoJS.enc.Utf16LE.parse(content1k);
    let startTime = Date.now()
    for (let i = 0; i < 1000; i++) {
        result = CryptoJS.enc.Utf16LE.stringify(words);
    }
    let endTime = Date.now()
    if (result != content1k) {
        throw 'Utf16LE.stringify error'
    }
    print(`crypto-js_Utf16LE.stringify: ${endTime - startTime} ms`)
}

crypto_Test_01()
crypto_Test_02()
crypto_Test_03()
crypto_Test_04()
crypto_Test_05()
crypto_Test_06()
crypto_Test_07()
crypto_Test_08()
crypto_Test_09()
crypto_Test_10()
crypto_Test_11()
crypto_Test_12()
crypto_Test_13()
crypto_Test_14()
crypto_Test_15()
crypto_Test_16()
crypto_Test_17()
crypto_Test_18()
crypto_Test_19()
crypto_Test_20()
crypto_Test_21()
crypto_Test_22()
crypto_Test_23()
crypto_Test_24()
crypto_Test_25()
crypto_Test_26()
crypto_Test_27()
crypto_Test_28()
crypto_Test_29()
crypto_Test_30()
crypto_Test_31()
crypto_Test_32()
crypto_Test_33()
crypto_Test_34()
crypto_Test_35()
crypto_Test_36()
crypto_Test_37()
crypto_Test_38()
crypto_Test_39()
crypto_Test_40()
crypto_Test_41()
crypto_Test_42()
crypto_Test_43()
crypto_Test_44()
crypto_Test_45()
crypto_Test_46()
crypto_Test_47()
crypto_Test_48()
crypto_Test_49()
crypto_Test_50()
crypto_Test_51()
crypto_Test_52()
crypto_Test_53()
crypto_Test_54()
crypto_Test_55()
crypto_Test_56()
crypto_Test_57()
crypto_Test_58()
crypto_Test_59()
crypto_Test_60()
crypto_Test_61()
crypto_Test_62()
crypto_Test_63()
crypto_Test_64()
crypto_Test_65()
crypto_Test_66()
crypto_Test_67()
crypto_Test_68()
crypto_Test_69()
crypto_Test_70()
crypto_Test_71()
crypto_Test_72()
crypto_Test_73()
crypto_Test_74()
crypto_Test_75()
crypto_Test_76()
crypto_Test_77()
crypto_Test_78()
crypto_Test_79()
crypto_Test_80()
crypto_Test_81()
crypto_Test_82()
